/**
 * 网络通用类
 * @class
 * 
 * @param {Object} config - json格式配置参数
 * @param {string} [config.baseUrl=''] - 请求根路径
 * @param {Boolean} [config.debug='false']	true - 在控制台输出调试信息; false - 控制台不输出调试信息
 * @param {string} [config.successCode='0'] - 调用成功码值，默认0
 * @param {Object[]} [config.errorCodeActions=[]] - 业务错误码对应的回调配置，json格式数组
 * @param {string} [config.errorCodeActions[].code] - 错误码值
 * @param {string} [config.errorCodeActions[].callback] - 回调函数，参数为jquery ajax请求成功后的参数序列
 * @param {Object[]} [config.supressCodes=[]]	禁用错误处理的错误码数组
 */
function HttpClient(config){
	/**
	 * 请求根目录
	 * @private
	 */
	var _baseUrl = '';
	
	/**
	 * 获得请求根目录
	 * @function
	 * @returns {string} 请求根目录
	 */
	this.baseUrl = function(){
		return _baseUrl;
	}
	
	/**
	 * debug模式
	 * @private
	 */
	var _debug = false;
	
	/**
	 * 获得debug模式
	 * @function
	 * @returns {Boolean} debug模式
	 */
	this.debug = function(){
		return _debug;
	}
	
	/**
	 * 业务错误码配置
	 * @private
	 */
	var _errorCodeActions = [];
	
	/**
	 * 获得业务错误码配置 
	 * @function
	 * @returns {Array} 业务错误码数组
	 */
	this.errorCodeActions = function(){
		return _errorCodeActions;
	}
	
	/**
	 * 禁用错误处理的错误码列表
	 * @private
	 */
	var _supressCodes = [];
	
	/**
	 * 获得禁用错误处理的错误码列表
	 * @function
	 * @returns {Array} 禁用错误处理的错误码数组
	 */
	this.supressCodes = function(){
		return _supressCodes;
	}
	
	/**
	 * 调用成功状态码
	 * @private
	 */
	var _successCode = 0;
	
	/**
	 * 获得调用成功状态码
	 * @function
	 * @returns {string} 调用成功状态码
	 */
	this.successCode = function(){
		return _successCode;
	}
	
	if(config){
		_baseUrl = config.baseUrl ? config.baseUrl : '';
		_debug = config.debug ? config.debug : false;
		_errorCodeActions = config.errorCodeActions ? config.errorCodeActions : [];
		_supressCodes = config.supressCodes ? config.supressCodes : [];
		_successCode = config.successCode ? config.successCode : 0;
	}
	
	var self = this;
	
	/**
	 * jquery ajax请求代理，如果是本地模式，则从静态js文件中加载变量。
	 * 如url为 my/test, tpye为get；则默认加载变量名称get_my_test；如type为post, 则默认加载变量post_my_test，如果都找不到，则尝试my_test
	 * @function
	 * @param {Object} request - jquery ajax参数
	 * @param {callback} [request.afterRequest] - ajax调用成功或失败的回调函数
	 */
	this.ajax = function(request){
		var type = request.type ? request.type : 'get';
		
		logger('正在请求 ' + request.url);
		
		if(typeof(Debug) != "undefined" && Debug.isLocalMode()){
			// 本地模式
			var vname = request.url.replace(/\//g, '_');	// 将url中所有斜线'/'替换成下划线
			vname = vname.split('?')[0];
			if(vname.startsWith('_')){
				vname = vname.substr(1);	// 去除首下划线
			}
			
			var data;
//				if(request.data && request.data.page){	// 分页相关
				// TODO
//					var origName = vname;
//					vname = vname + request.data.page;
//					try{
//						data = eval(vname);
//					}catch(e){
//						data = eval(origName + '1');
//					}
//				}else{
			try{
				var v = type + '_' + vname;
				data = eval(v);	// 加载
			}catch(e){
				logger('没有找到变量[' + v + '], 继续尝试寻找变量[' + vname + ']', 'w');
				try{
					data = eval(vname);
				}catch(ee){
					logger(ee);
				}
			}
			
			logger(data);
			
			if(request.success){
				validate(data);
				request.success(data);
			}
			
			if(request.afterRequest){
				request.afterRequest(data);
			}
		}else{
			var data = request.data ? request.data : {};
			
			var success = request.success;
			var afterRequest = request.afterRequest;
			var error = request.error;
			
			request.success = function(data, textStatus, jqXHR){
				validate(data);
				
				if(success){
					success(data, textStatus, jqXHR);
				}
				
				if(afterRequest){
					afterRequest(data);
				}				
			}
			
			request.error = function(XMLHttpRequest, textStatus, errorThrown){
				if(error){
					error(XMLHttpRequest, textStatus, errorThrown);
				}
				if(afterRequest){
					afterRequest();
				}
			}
			
			request.url = _baseUrl + request.url;
			$.ajax(request);
			
//			$.ajax({
//				type: type,
//				url: _baseUrl + url,
//				async: async,
//				contentType : contentType,
//				data: data,
//				dataType: dataType,
//				success: function(data, textStatus, jqXHR){
//					validate(data);
//					
//					if(request.success){
//						request.success(data, textStatus, jqXHR);
//					}
//					
//					if(request.afterRequest){
//						request.afterRequest(data);
//					}
//				},
//				error: function(XMLHttpRequest, textStatus, errorThrown){
//					if(request.error){
//						request.error(XMLHttpRequest, textStatus, errorThrown);
//					}
//					if(request.afterRequest){
//						request.afterRequest(data);
//					}
//				}
//			});			
		}
		
		/**
		 * 校验ajax返回的数据
		 */
		function validate(data){
			if(data.code != _successCode){
				// 错误码处理
				for(var i in _errorCodeActions){
					var code = _errorCodeActions[i].code;
					var callback = _errorCodeActions[i].callback;
					
					// 错误码处理
					if(data.code == code){
						// 查看是否禁用了此错误码
						var disabled = false;
						for(var j in _supressCodes){
							if(data.code == _supressCodes[j]){
								// 错误码被禁用
								disabled = true;
								logger('错误码' + data.code + '回调被禁用');
							}
						}
						
						if(!disabled){
							callback(data);
						}
						
						break;
					}
				}
			}
		}
	}
	
	/**
	 * 输出控制台日志
	 * 如果是本地模式，默认输出调试信息
	 * 对于服务器模式，如果debug标志为true，则输出调试信息
	 */
	function logger(text, level){
		if(!text){
			return;
		}
		
		if((typeof(Debug) != "undefined" && Debug.isLocalMode()) || _debug){
			if(level == 'i'){
				console.info(text);
			}else if(level == 'w'){
				console.warn(text);
			}else if(level == 'e'){
				console.error(text);
			}else if('level' == 't'){
				console.trace(text);
			}else{
				console.info(text);
			}
		}
	}
}
